La conversion numérique de la chaîne numérique en Ruby

Je veux une méthode comme to_numeric(str) qui convertissent la chaîne numérique 'str' dans sa forme numérique else return nil. Par forme numérique si la chaîne est en entier méthode doit retourner integer et string est en float, il doit retourner à flotteur.

J'ai essayé avec le code suivant. Il fonctionne très bien mais ont besoin d'une meilleure solution si possible.

def to_numeric(str)
  Integer(str)
rescue
  Float(str) if Float(str) rescue nil
end

Une chose importante que j'ai oublié de mentionner, c'est "je ne sais pas le type de mon entrée".

Mon cas d'utilisation:

arr = [1, 1.5, 2, 2.5, 4]
some_input = get_input_from_some_source

if arr.include?(to_numeric(some_input))
  # do something
end
  • essayez to_i méthode de la classe string ruby-doc.org/core-1.9.3/String.html#method-i-to_i
  • Par "numérique", je veux dire entiers et à virgule flottante. Je veux convertir "1" ou "1.34" pour sa forme numérique.
  • to_i donne integer ou float, en particulier, un nombre entier.
  • "1.23".to_i donne 1, pas 1.23
  • Oui, c'est vrai. Exactement.
  • veuillez expliquer pourquoi il est important d'obtenir le "bon" type? Si l'on pouvait flotter, pourquoi ne pas toujours se convertir à flotter?
  • Je ne comprends pas le "donne integer ou float" partie, pourriez-vous l'expliquer?
  • to_i renvoie un entier, elle retourne un entier ou un flottant. @nathanvda Non, j'ai répondu à la deuxième commentaire.
  • Euh @sawa, elle renvoie un entier, elle retourne un entier 😉
  • qui est correct. Mais pas sûr si c'est le cas des OP cas. Peut-être qu'il n'est tout simplement pas compétent en ruby, il veut juste pour convertir des chaînes à leur représentation numérique pour les stocker dans la base de données.
  • Il n'a rien à voir avec le Rubis. Simplement, l'OP n'a pas formulé la question. Ce problème vient de là. L'OP écrit que "numérique", et n'a pas une seule mention de ce que la classe d'attendre dans quelles circonstances. L'OP s'attend le lecteur à deviner tout cela et est en train d'être paresseux.
  • veuillez vérifier mes mises à jour de question pour mon cas d'utilisation.
  • suffit d'utiliser des flotteurs [4].include? 4.0 #=> true
  • à partir de votre cas d'utilisation, il semble que myInput.to_f ferait l'affaire, mais si c'est votre précis de cas d'utilisation, alors vous pouvez avoir besoin de le changer. Les comparaisons entre les floats/doubles/.. n'est pas toujours ce que vous attendez. Le nombre 1.5 pourrait ne pas être possible de stocker exactement-comme-il-est dans un "type numérique". Il peut être 1.5000000001. Si après l'analyse de l'entrée, vous obtenez 1.49999999, vous ne le trouveriez pas dans le tableau en simple include?.
  • D'accord avec ça. Mais je sais que la comparaison de la source de 'arr'(ici) qu'il va contenir soit entier ou à virgule flottante en arrondissant à 2. Alors, peut dans ce cas je peux arrondir entrée à 2 et pourrait utiliser la méthode to_numeric. Ce que vous suggérez?

InformationsquelleAutor ram | 2013-11-21
  1. 11

    Vous pouvez utiliser BigDecimal#frac à réaliser ce que vous voulez

    require 'bigdecimal'

def to_numeric(anything)
  num = BigDecimal.new(anything.to_s)
  if num.frac == 0
    num.to_i
  else
    num.to_f
  end
end

    Il peut gérer

    #floats
to_numeric(2.3) #=> 2.3

#rationals
to_numeric(0.2E-4) #=> 2.0e-05

#integers
to_numeric(1) #=> 1

#big decimals
to_numeric(BigDecimal.new("2"))

    Et des flotteurs, des rationnels et des nombres entiers en forme de chaînes de caractères, trop

    • +1 Cette solution laisse la conversion d'un rubis de la bibliothèque et est facile à lire (=maintien) (bien qu'il ne peut gérer que des chaînes de caractères en entrée)
    • Maintenant, il peut prendre quoi que ce soit de répondre à #to_s comme entrée 🙂
    • Pourquoi le downvote?
    • Sentir da Beat! Belle solution! Mais gardez à l'esprit les deux cas suivants ne sont pas vraiment traités par la solution proposée gentiment: [CAS 1] to_numeric(1.0000000000000001) / 2 => 0, alors que si nous omettons to_numeric appel, puis nous allons obtenir des résultats différents: 1.0000000000000001 / 2 => 0.5 [CAS 2] to_numeric(1.0) => 1, donc encore une fois si nous sommes à l'utilisation des "to_numeric()" pour décortiquer le flux de chaînes de caractères qui représentent des nombres, ces deux cas peuvent nous mordre dans notre cul 😉 ps: Ce n'est pas moi downvoting : )
    • Je vais juste laisser ça ici: Integer('0010') => 8
    InformationsquelleAutor Beat Richartz
  2. 4

    Convertir Float à l'aide de String#to_f méthode. Depuis ruby en utilisant duck-typing vous ne pouvez pas les soins si elle peut être un Integer.

    Si elle ressemble à un numérique, nage comme un numérique et des charlatans comme un numérique, alors il est probablement un numérique.

    Mais attention! to_f ne pas jeter des exceptions:

    "foobar".to_f # => 0
    • "1.2".to_f # 1.2 OK. Mais "1".to_f # 1.0 Ne Ok. J'ai besoin de convertisseur qui va "1.2" (1,2 et "1" à 1.
    • et si vous voulez avoir Entier, puis utilisez "123".to_i
    • en fait, même en Ruby, vous devrait "se soucier des entiers". Le calcul des opérateurs tels que / travailler différemment sur eux, de sorte d'avoir 2 / 3 n'est pas la même que la 2.0 / 3.0, et d'avoir tout dans la flotte n'est pas toujours la bonne façon 🙂 je ne dis pas que votre réponse est fausse. Je viens de dire vous avez des soins.
    • oui, merci. Et je suis assez sûr que l'exploitation des hydravions sont plus lents.
    InformationsquelleAutor user2422869
  3. 2

    Si vraiment vous insistez pour différencier entre les Entiers et des flottants, alors vous pouvez mettre en œuvre to_numeric comme ceci:

    def to_numeric(thing)
  return thing.to_s.to_i if thing.to_s == thing.to_s.to_i.to_s  
  return thing.to_s.to_f if thing.to_s == thing.to_s.to_f.to_s  
  thing
end

    Il convertit un objet en entier, si sa représentation sous forme de chaîne ressemble à un entier (même avec flotteur), ou renvoie la inchangée chose si ce n':

    ['1', '1.5', 'foo', :bar, '2', '2.5', File].map {|obj| to_numeric obj}
# => [1, 1.5, "foo", :bar, 2, 2.5, File]
    • Cela semble bien répondre à mon cas d'utilisation. Merci.
    • J'ai besoin de reconsidérer cette solution comme to_numeric("0.2 E-4") est de retour "de 0,2 E-4"(chaîne de caractères). Constaté que "0.2 E-4".to_s.to_f.to_s est de retour "2.0 e-05" (Étrange).
    • Triste, mais vrai 🙂 je pense que @beat-richarts la solution gère mieux.
    • Oui. Avez-vous essayé ma solution. Il fonctionne pour tous les cas sauf BigDecimal. 🙂
    • Cette approche ne fonctionne pas pour des chaînes telles que 0.000001 où la to_s fonction peut retourner "1.0 e-05". L'expression s == s.to_f.to_s également fait des hypothèses à propos de précision en virgule flottante qui peut être incorrect.
    InformationsquelleAutor tessi
  4. 2

    Voici quelques options:

    1. Utiliser des flotteurs pour la comparaison:

      arr = [1, 1.5, 2, 2.5, 4]
arr.include? "4.0".to_f #=> true

    2. Utiliser des chaînes à des fins de comparaison:

      arr = %w(1 1.5 2 2.5 4)
arr.include? "4" #=> true

    3. Utilisation eval pour la conversion:

      eval("4.0") #=> 4.0
eval("4")   #=> 4

      Mais vous devez être très prudent lors de l'utilisation de eval, voir @tessi commentaire.

    • L'OP fait son entrée à partir de la get_input_from_some_source. Ce n' pas sonne comme une bonne entrée pour eval.
    • Oui, vous avez pour vérifier l'entrée avant de les passer à la fonction eval. Un simple Regexp devrait faire l'affaire.
    • Droit, mais il faut être prudent suggérant eval. Un "simple regexp" comme /^\d*\.?\d*$/ pourrait encore être nocif pour une chaîne comme "42\nFile.delete(__FILE__)". eval est une solution valable (il suffit d'utiliser \A et \z dans la regexp) mais n'est pas une bonne recommandation pour les débutants.
    • Bien sûr, et je ne pense pas qu'il soit nécessaire d'utiliser eval ici, j'ai juste ajouté ça comme un exemple pour convertir un String soit Float ou Integer (l'OP question d'origine).
    InformationsquelleAutor Stefan