Déterminer si une chaîne est valide valeur float

Voici un moyen:

class String
  def valid_float?
    # The double negation turns this into an actual boolean true - if you're 
    # okay with "truthy" values (like 0.0), you can remove it.
    !!Float(self) rescue false
  end
end

"a".valid_float? #false
"2.4".valid_float? #true

Si vous voulez éviter le singe-patch de la Chaîne, vous pouvez toujours en faire une méthode de classe de certains module de contrôle, bien sûr:

module MyUtils
  def self.valid_float?(str)
    !!Float(str) rescue false
  end
end
MyUtils.valid_float?("a") #false

J'ai vu la discussion non résolus sur cast+exceptions vs regex et j'ai pensé que je voudrais essayer de référence de tout et de produire une réponse objective:

Ici est la source pour le meilleur des cas et le pire de chaque méthode tenté ici:

require "benchmark"
n = 500000
def is_float?(fl)
!!Float(fl) rescue false
end
def is_float_reg(fl)
fl =~ /(^(\d+)(\.)?(\d+)?)|(^(\d+)?(\.)(\d+))/
end
class String
def to_float
Float self rescue (0.0 / 0.0)
end
end
Benchmark.bm(7) do |x|
x.report("Using cast best case") {
n.times do |i|
temp_fl = "#{i + 0.5}"
is_float?(temp_fl)
end
}
x.report("Using cast worst case") {
n.times do |i|
temp_fl = "asdf#{i + 0.5}"
is_float?(temp_fl)
end
}
x.report("Using cast2 best case") {
n.times do |i|
"#{i + 0.5}".to_float
end
}
x.report("Using cast2 worst case") {
n.times do |i|
"asdf#{i + 0.5}".to_float
end
}
x.report("Using regexp short") {
n.times do |i|
temp_fl = "#{i + 0.5}"
is_float_reg(temp_fl)
end
}
x.report("Using regexp long") {
n.times do |i|
temp_fl = "12340918234981234#{i + 0.5}"
is_float_reg(temp_fl)
end
}
x.report("Using regexp short fail") {
n.times do |i|
temp_fl = "asdf#{i + 0.5}"
is_float_reg(temp_fl)
end
}
x.report("Using regexp long fail") {
n.times do |i|
temp_fl = "12340918234981234#{i + 0.5}asdf"
is_float_reg(temp_fl)
end
}
end

Avec les résultats suivants avec mri193:

              user     system      total        real
Using cast best case  0.608000   0.000000   0.608000 (  0.615000)
Using cast worst case  5.647000   0.094000   5.741000 (  5.745000)
Using cast2 best case  0.593000   0.000000   0.593000 (  0.586000)
Using cast2 worst case  5.788000   0.047000   5.835000 (  5.839000)
Using regexp short  0.951000   0.000000   0.951000 (  0.952000)
Using regexp long  1.217000   0.000000   1.217000 (  1.214000)
Using regexp short fail  1.201000   0.000000   1.201000 (  1.202000)
Using regexp long fail  1.295000   0.000000   1.295000 (  1.284000)

Puisque nous avons affaire à un temps Linéaire algorithmes je pense que nous utilisons des mesures empiriques de faire des généralisations. Il est facile de voir que la regex est plus cohérente et ne fluctuent un peu en fonction de la longueur de la chaîne passée. Le casting est clairement plus rapide quand il n'y a pas d'échec, et beaucoup plus lent quand il y a des échecs.

Si l'on compare la réussite fois, nous pouvons voir que le casting dans le meilleur des cas est d'environ de 3 secondes plus vite que la regex dans le meilleur des cas. Si nous divisons ce chiffre par la quantité de temps dans le cas le pire des cas, on peut estimer le nombre de pistes qu'il faudrait pour casser même avec des exceptions, le ralentissement de la distribution vers le bas pour correspondre à la regex de vitesses. Environ 6 secondes plongé par .3 nous donne environ 20. Donc, si la performance est importante et vous vous attendez à moins de 1 au 20 de votre test à l'échec alors utilisé en fonte+exceptions.

JRuby 1.7.4 a des résultats complètement différents:

              user     system      total        real
Using cast best case  2.575000   0.000000   2.575000 (  2.575000)
Using cast worst case 53.260000   0.000000  53.260000 ( 53.260000)
Using cast2 best case  2.375000   0.000000   2.375000 (  2.375000)
Using cast2 worst case 53.822000   0.000000  53.822000 ( 53.822000)
Using regexp short  2.637000   0.000000   2.637000 (  2.637000)
Using regexp long  3.395000   0.000000   3.395000 (  3.396000)
Using regexp short fail  3.072000   0.000000   3.072000 (  3.073000)
Using regexp long fail  3.375000   0.000000   3.375000 (  3.374000)

Cast n'est que légèrement plus rapide dans le meilleur des cas (environ 10%). En présumant que cette différence est approprié pour faire des généralisations(je ne pense pas qu'il l'est), alors le seuil de rentabilité se situe entre 200 et 250 fonctionne avec seulement 1 provoquer une exception.

Si les exceptions ne devraient être utilisé quand elles sont vraiment exceptionnelles, il se passe des choses, c'est une décision pour vous et votre base de code. Quand ils ne sont pas utilisés code, qu'ils sont peut être plus simple et plus rapide.

Si la performance n'est pas grave, vous devriez probablement juste après en fonction de ce que les conventions de l'équipe ou de la base de code a déjà et ignorer cet ensemble de réponses.

Essayer cette

def is_float(val)
fval = !!Float(val) rescue false
# if val is "1.50" for instance
# we need to lop off the trailing 0(s) with gsub else no match
return fval && Float(val).to_s == val.to_s.gsub(/0+$/,'') ? true:false
end 
s = "1000"
is_float s
=> false 
s = "1.5"
is_float s
=> true 
s = "Bob"
is_float s
=> false
n = 1000
is_float n
=> false 
n = 1.5
is_float n
=> true

J'ai essayé de l'ajouter comme commentaire, mais apparemment il n'y a pas de mise en forme dans les commentaires:

d'autre part, pourquoi ne pas simplement de l'utiliser comme fonction de conversion, comme

class String
def to_float
Float self rescue (0.0 / 0.0)
end
end
"a".to_float.nan? => true

qui est bien sûr ce que vous ne voulez pas le faire en premier lieu. Je suppose que la réponse est: "vous devez écrire votre propre fonction si vous ne voulez vraiment pas à utiliser la gestion des exceptions, mais, pourquoi le feriez-vous?"