Question

我相信我对这个问题有一个很好的答案，但我想确保ruby-philes没有更好的方法来做到这一点。

基本上，给定一个输入字符串，我想在适当的情况下将字符串转换为整数，或者在适当的时候将其转换为浮点数。否则，只需返回字符串。

我会在下面发布我的答案，但我想知道是否有更好的方法。

例如：

to_f_or_i_or_s("0523.49") #=> 523.49
to_f_or_i_or_s("0000029") #=> 29
to_f_or_i_or_s("kittens") #=> "kittens"

Answer 1

我会尽可能避免在Ruby中使用正则表达式。这是出了名的慢。

def to_f_or_i_or_s(v)
  ((float = Float(v)) && (float % 1.0 == 0) ? float.to_i : float) rescue v
end

# Proof of Ruby's slow regex
def regex_float_detection(input)
  input.match('\.')
end

def math_float_detection(input)
  input % 1.0 == 0
end

n = 100_000
Benchmark.bm(30) do |x|
  x.report("Regex") { n.times { regex_float_detection("1.1") } }
  x.report("Math") { n.times { math_float_detection(1.1) } }
end

#                                     user     system      total        real
# Regex                           0.180000   0.000000   0.180000 (  0.181268)
# Math                            0.050000   0.000000   0.050000 (  0.048692)

更全面的基准：

def wattsinabox(input)
  input.match('\.').nil? ? Integer(input) : Float(input) rescue input.to_s
end

def jaredonline(input)
  ((float = Float(input)) && (float % 1.0 == 0) ? float.to_i : float) rescue input
end

def muistooshort(input)
  case(input)
  when /\A\s*[+-]?\d+\.\d+\z/
      input.to_f
  when /\A\s*[+-]?\d+(\.\d+)?[eE]\d+\z/
      input.to_f
  when /\A\s*[+-]?\d+\z/ 
      input.to_i     
  else  
      input
  end
end

n = 1_000_000
Benchmark.bm(30) do |x|
  x.report("wattsinabox") { n.times { wattsinabox("1.1") } }
  x.report("jaredonline") { n.times { jaredonline("1.1") } }
  x.report("muistooshort") { n.times { muistooshort("1.1") } }
end

#                                     user     system      total        real
# wattsinabox                     3.600000   0.020000   3.620000 (  3.647055)
# jaredonline                     1.400000   0.000000   1.400000 (  1.413660)
# muistooshort                    2.790000   0.010000   2.800000 (  2.803939)

Answer 2

def to_f_or_i_or_s(v)
    v.match('\.').nil? ? Integer(v) : Float(v) rescue v.to_s
end

Answer 3

如果你想用科学记数法处理数字（String#to_f会这样做），那么一堆正则表达式可能是个好主意：

def to_f_or_i_or_s(v)
    case(v)
    when /\A\s*[+-]?\d+\.\d+\z/
        v.to_f
    when /\A\s*[+-]?\d+(\.\d+)?[eE]\d+\z/
        v.to_f
    when /\A\s*[+-]?\d+\z/ 
        v.to_i     
    else  
        v
    end
end

如果您愿意，可以将to_f个案例混合到一个正则表达式中。

当在使用逗号作为小数分隔符的语言环境中提供'3,14159'时，这将失败。

Answer 4

取决于安全要求。

def to_f_or_i_or_s s
    eval(s) rescue s
end

Answer 5

我使用了这种方法

  def to_f_or_i_or_s(value)
    return value if value[/[a-zA-Z]/]

    i = value.to_i
    f = value.to_f

    i == f ? i : f
  end

Answer 6

CSV有转换器执行此操作。

require "csv"
strings = ["0523.49", "29","kittens"]
strings.each{|s|p s.parse_csv(converters: :numeric).first}

#523.49
#29
#"kittens"

但由于某种原因，它将“00029”转换为浮动。

使用Ruby将输入值转换为整数或浮点数

6 个答案: