Prueba si la cadena es un número en Ruby on Rails

Tengo lo siguiente en mi controlador de aplicación:

def is_number?(object)
  true if Float(object) rescue false
end

y la siguiente condición en mi controlador:

if mystring.is_number?

end

La condición arroja un undefined methoderror. ¿Supongo que lo he definido is_numberen el lugar equivocado ...?

Crear is_number?método.

Crea un método auxiliar:

def is_number? string
  true if Float(string) rescue false
end

Y luego llámalo así:

my_string = '12.34'

is_number?( my_string )
# => true

Ampliar Stringclase.

Si desea poder llamar is_number?directamente a la cadena en lugar de pasarla como un parámetro a su función auxiliar, debe definir is_number?como una extensión de la Stringclase, así:

class String
  def is_number?
    true if Float(self) rescue false
  end
end

Y luego puedes llamarlo con:

my_string.is_number?
# => true

Aquí hay un punto de referencia para las formas comunes de abordar este problema. Tenga en cuenta cuál debe usar probablemente depende de la proporción de casos falsos esperados.

1. Si son relativamente poco comunes, el casting es definitivamente más rápido.
2. Si los casos falsos son comunes y solo está buscando entradas, la comparación frente a un estado transformado es una buena opción.
3. Si los casos falsos son comunes y está verificando flotantes, regexp probablemente sea el camino a seguir

Si el rendimiento no importa, usa lo que te gusta. :-)

Detalles de verificación de enteros:

# 1.9.3-p448
#
# Calculating -------------------------------------
#                 cast     57485 i/100ms
#            cast fail      5549 i/100ms
#                 to_s     47509 i/100ms
#            to_s fail     50573 i/100ms
#               regexp     45187 i/100ms
#          regexp fail     42566 i/100ms
# -------------------------------------------------
#                 cast  2353703.4 (±4.9%) i/s -   11726940 in   4.998270s
#            cast fail    65590.2 (±4.6%) i/s -     327391 in   5.003511s
#                 to_s  1420892.0 (±6.8%) i/s -    7078841 in   5.011462s
#            to_s fail  1717948.8 (±6.0%) i/s -    8546837 in   4.998672s
#               regexp  1525729.9 (±7.0%) i/s -    7591416 in   5.007105s
#          regexp fail  1154461.1 (±5.5%) i/s -    5788976 in   5.035311s

require 'benchmark/ips'

int = '220000'
bad_int = '22.to.2'

Benchmark.ips do |x|
  x.report('cast') do
    Integer(int) rescue false
  end

  x.report('cast fail') do
    Integer(bad_int) rescue false
  end

  x.report('to_s') do
    int.to_i.to_s == int
  end

  x.report('to_s fail') do
    bad_int.to_i.to_s == bad_int
  end

  x.report('regexp') do
    int =~ /^\d+$/
  end

  x.report('regexp fail') do
    bad_int =~ /^\d+$/
  end
end

Detalles de verificación de flotación:

# 1.9.3-p448
#
# Calculating -------------------------------------
#                 cast     47430 i/100ms
#            cast fail      5023 i/100ms
#                 to_s     27435 i/100ms
#            to_s fail     29609 i/100ms
#               regexp     37620 i/100ms
#          regexp fail     32557 i/100ms
# -------------------------------------------------
#                 cast  2283762.5 (±6.8%) i/s -   11383200 in   5.012934s
#            cast fail    63108.8 (±6.7%) i/s -     316449 in   5.038518s
#                 to_s   593069.3 (±8.8%) i/s -    2962980 in   5.042459s
#            to_s fail   857217.1 (±10.0%) i/s -    4263696 in   5.033024s
#               regexp  1383194.8 (±6.7%) i/s -    6884460 in   5.008275s
#          regexp fail   723390.2 (±5.8%) i/s -    3613827 in   5.016494s

require 'benchmark/ips'

float = '12.2312'
bad_float = '22.to.2'

Benchmark.ips do |x|
  x.report('cast') do
    Float(float) rescue false
  end

  x.report('cast fail') do
    Float(bad_float) rescue false
  end

  x.report('to_s') do
    float.to_f.to_s == float
  end

  x.report('to_s fail') do
    bad_float.to_f.to_s == bad_float
  end

  x.report('regexp') do
    float =~ /^[-+]?[0-9]*\.?[0-9]+$/
  end

  x.report('regexp fail') do
    bad_float =~ /^[-+]?[0-9]*\.?[0-9]+$/
  end
end

class String
  def numeric?
    return true if self =~ /\A\d+\Z/
    true if Float(self) rescue false
  end
end  

p "1".numeric?  # => true
p "1.2".numeric? # => true
p "5.4e-29".numeric? # => true
p "12e20".numeric? # true
p "1a".numeric? # => false
p "1.2.3.4".numeric? # => false

Confiar en la excepción planteada no es la solución más rápida, legible ni confiable.
Haría lo siguiente:

my_string.should =~ /^[0-9]+$/

A partir de Ruby 2.6.0, los métodos de exceptionconversión numéricos tienen un argumento opcional [1] . Esto nos permite usar los métodos integrados sin usar excepciones como flujo de control:

Float('x') # => ArgumentError (invalid value for Float(): "x")
Float('x', exception: false) # => nil

Por lo tanto, no tiene que definir su propio método, pero puede verificar directamente variables como, por ejemplo,

if Float(my_var, exception: false)
  # do something if my_var is a float
end

así es como lo hago, pero creo que también debe haber una mejor manera

object.to_i.to_s == object || object.to_f.to_s == object

no, solo lo estás usando mal. tu es_number? tiene un argumento. lo llamaste sin el argumento

deberías estar haciendo is_number? (mystring)

Tl; dr: use un enfoque de expresiones regulares. Es 39 veces más rápido que el enfoque de rescate en la respuesta aceptada y también maneja casos como "1,000"

def regex_is_number? string
  no_commas =  string.gsub(',', '')
  matches = no_commas.match(/-?\d+(?:\.\d+)?/)
  if !matches.nil? && matches.size == 1 && matches[0] == no_commas
    true
  else
    false
  end
end

-

La respuesta aceptada por @Jakob S funciona en su mayor parte, pero detectar excepciones puede ser muy lento. Además, el enfoque de rescate falla en una cadena como "1,000".

Definamos los métodos:

def rescue_is_number? string
  true if Float(string) rescue false
end

def regex_is_number? string
  no_commas =  string.gsub(',', '')
  matches = no_commas.match(/-?\d+(?:\.\d+)?/)
  if !matches.nil? && matches.size == 1 && matches[0] == no_commas
    true
  else
    false
  end
end

Y ahora algunos casos de prueba:

test_cases = {
  true => ["5.5", "23", "-123", "1,234,123"],
  false => ["hello", "99designs", "(123)456-7890"]
}

Y un pequeño código para ejecutar los casos de prueba:

test_cases.each do |expected_answer, cases|
  cases.each do |test_case|
    if rescue_is_number?(test_case) != expected_answer
      puts "**rescue_is_number? got #{test_case} wrong**"
    else
      puts "rescue_is_number? got #{test_case} right"
    end

    if regex_is_number?(test_case) != expected_answer
      puts "**regex_is_number? got #{test_case} wrong**"
    else
      puts "regex_is_number? got #{test_case} right"
    end  
  end
end

Aquí está el resultado de los casos de prueba:

rescue_is_number? got 5.5 right
regex_is_number? got 5.5 right
rescue_is_number? got 23 right
regex_is_number? got 23 right
rescue_is_number? got -123 right
regex_is_number? got -123 right
**rescue_is_number? got 1,234,123 wrong**
regex_is_number? got 1,234,123 right
rescue_is_number? got hello right
regex_is_number? got hello right
rescue_is_number? got 99designs right
regex_is_number? got 99designs right
rescue_is_number? got (123)456-7890 right
regex_is_number? got (123)456-7890 right

Es hora de hacer algunas evaluaciones comparativas de rendimiento:

Benchmark.ips do |x|

  x.report("rescue") { test_cases.values.flatten.each { |c| rescue_is_number? c } }
  x.report("regex") { test_cases.values.flatten.each { |c| regex_is_number? c } }

  x.compare!
end

Y los resultados:

Calculating -------------------------------------
              rescue   128.000  i/100ms
               regex     4.649k i/100ms
-------------------------------------------------
              rescue      1.348k (±16.8%) i/s -      6.656k
               regex     52.113k (± 7.8%) i/s -    260.344k

Comparison:
               regex:    52113.3 i/s
              rescue:     1347.5 i/s - 38.67x slower

En rails 4, debe require File.expand_path('../../lib', __FILE__) + '/ext/string' ingresar su config / application.rb

Si prefiere no usar excepciones como parte de la lógica, puede intentar esto:

class String
   def numeric?
    !!(self =~ /^-?\d+(\.\d*)?$/)
  end
end

O, si desea que funcione en todas las clases de objetos, reemplácelo class Stringcon class Objectun convert self en una cadena: !!(self.to_s =~ /^-?\d+(\.\d*)?$/)

usa la siguiente función:

def is_numeric? val
    return val.try(:to_f).try(:to_s) == val
end

entonces,

is_numeric? "1.2f" = falso

is_numeric? "1.2" = verdadero

is_numeric? "12f" = falso

is_numeric? "12" = verdadero

¿Qué tan tonta es esta solución?

def is_number?(i)
  begin
    i+0 == i
  rescue TypeError
    false
  end
end