ruby - section - wbr tag in html5

Análisis entero seguro en Ruby

Question

Tengo una cadena, digamos ''123'' , y quiero convertirla a 123 .

Sé que puedes simplemente hacer some_string.to_i , pero eso convierte a ''lolipops'' en 0 , que no es el efecto que tengo en mente. Quiero que explote en mi cara cuando trato de convertir algo inválido, con una agradable y dolorosa Exception . De lo contrario, no puedo distinguir entre un 0 válido y algo que simplemente no es un número en absoluto.

EDITAR: Estaba buscando la forma estándar de hacerlo, sin engaños regex.

Answer 1

Esto podría funcionar:

i.to_i if i.match(/^/d+$/)

Answer 2

Me gusta la respuesta de Myron, pero sufre de la enfermedad de Ruby de "Ya no uso Java / C #, así que nunca volveré a utilizar la herencia" . Abrir cualquier clase puede ser peligroso y debe usarse con moderación, especialmente cuando es parte de la biblioteca principal de Ruby. No digo que nunca lo use, pero generalmente es fácil de evitar y hay mejores opciones disponibles, por ejemplo

class IntegerInString < String

  def initialize( s )
    fail ArgumentError, "The string ''#{s}'' is not an integer in a string, it''s just a string." unless s =~ /^/-?[0-9]+$/
    super
  end
end

Entonces, cuando desee utilizar una cadena que podría ser un número, está claro lo que está haciendo y no le molesta a ninguna clase central, por ejemplo

n = IntegerInString.new "2"
n.to_i
# => 2

IntegerInString.new "blob"
ArgumentError: The string ''blob'' is not an integer in a string, it''s just a string.

Puede agregar todo tipo de otras comprobaciones en la inicialización, como buscar números binarios, etc. Lo principal, sin embargo, es que Ruby es para las personas y para las personas significa claridad . Nombrar un objeto a través de su nombre de variable y su nombre de clase hace las cosas mucho más claras.

Answer 3

Otro comportamiento inesperado con la solución aceptada (con 1.8, 1.9 está bien):

>> Integer(:foobar)
=> 26017
>> Integer(:yikes)
=> 26025

así que si no está seguro de lo que se está transmitiendo, asegúrese de agregar un .to_s .

Answer 4

Re: la respuesta de Chris

Su implementación permite el paso de "1a" o "b2". ¿Qué tal esto en su lugar?

def safeParse2(strToParse)
  if strToParse =~ //A/d+/Z/
    strToParse.to_i
  else
    raise Exception
  end
end

["100", "1a", "b2", "t"].each do |number|
  begin
    puts safeParse2(number)
  rescue Exception
    puts "#{number} is invalid"
  end
end

Esto produce:

100
1a is invalid
b2 is invalid
t is invalid

Answer 5

Ruby tiene esta funcionalidad integrada:

Integer(''1001'')                                    # => 1001  
Integer(''1001 nights'')  
# ArgumentError: invalid value for Integer: "1001 nights"  

Como señaló Joseph Pecoraro en su respuesta, es posible que desee buscar cadenas que sean números válidos no decimales, como los que comienzan con 0x para hexadecimal y 0b para binario, y potencialmente más complicados comenzando con cero que se analizarán como octal .

Ruby 1.9.2 añadió un segundo argumento opcional para radix, por lo que se puede evitar el problema anterior:

Integer(''23'')                                     # => 23
Integer(''0x23'')                                   # => 35
Integer(''023'')                                    # => 19
Integer(''0x23'', 10)
# => #<ArgumentError: invalid value for Integer: "0x23">
Integer(''023'', 10)                                # => 23

Answer 6

También tenga en cuenta los efectos que la solución aceptada actual puede tener en el análisis de números hexadecimales, octales y binarios:

>> Integer(''0x15'')
# => 21  
>> Integer(''0b10'')
# => 2  
>> Integer(''077'')
# => 63

En Ruby, los números que comienzan con 0x o 0X son hexadecimales, 0b o 0B son binarios, y solo 0 son octal. Si este no es el comportamiento deseado, puede combinarlo con algunas de las otras soluciones que comprueban si la cadena coincide primero con un patrón. Como las expresiones //d+/ regulares, etc.

Answer 7

Tuve que lidiar con esto en mi último proyecto, y mi implementación fue similar, pero un poco diferente:

class NotAnIntError < StandardError 
end

class String
  def is_int?    
    self =~ /^-?[0-9]+$/
  end

  def safe_to_i
    return self.to_i if is_int?
    raise NotAnIntError, "The string ''#{self}'' is not a valid integer.", caller
  end
end

class Integer
  def safe_to_i
    return self
  end            
end

class StringExtensions < Test::Unit::TestCase

  def test_is_int
    assert "98234".is_int?
    assert "-2342".is_int?
    assert "02342".is_int?
    assert !"+342".is_int?
    assert !"3-42".is_int?
    assert !"342.234".is_int?
    assert !"a342".is_int?
    assert !"342a".is_int?
  end

  def test_safe_to_i
    assert 234234 == 234234.safe_to_i
    assert 237 == "237".safe_to_i
    begin
      "a word".safe_to_i
      fail ''safe_to_i did not raise the expected error.''
    rescue NotAnIntError 
      # this is what we expect..
    end
  end

end

Answer 8

someString = "asdfasd123"
number = someString.to_i
if someString != number.to_s
  puts "oops, this isn''t a number"
end

Probablemente no sea la forma más limpia de hacerlo, pero debería funcionar.