L'implementazione di Ruby è_numerica? per le stringhe, sono necessarie alternative migliori

Question

Volevo convalidare la "numericità" di una stringa (non è un attributo in un modello di record attivo). Ho solo bisogno che sia una base valida 10, stringa intera positiva. Sto facendo questo:

class String 
    def numeric? 
    # Check if every character is a digit 
    !!self.match(/\A[0-9]+\Z/) 
    end 
end 

class String 
    def numeric? 
    # Check is there is *any* non-numeric character 
    !self.match(/[^0-9]/) 
    end 
end 

Quale di questi è un'alternativa più plausibile? O, c'è qualche altra migliore implementazione?

Answer 1

Assicurarsi uso \A e \Z piuttosto che ^ e $, per abbinare l'intera stringa piuttosto che solo una singola linea nella stringa. Se vuoi evitare di far corrispondere una stringa con una nuova fine, usa '\ z' alla fine. Per ulteriori problemi, vedere The Regex Tutorial on anchors.

Per esempio, /^[0-9]+$/ corrisponde con successo quanto segue:

foo 
1234 
bar 

ma /\A[0-9]+\Z/ non lo fa.

Answer 2

Il primo mi sembra sano di mente.

Vorrei nominare il metodo numeric?, tuttavia. Non sono un grande fan dei metodi is_foo?. Hanno senso nelle lingue che non hanno punti interrogativi nei nomi dei metodi (is_foo, isFoo), ma con il punto interrogativo, il is si sente ridondante.

Answer 3

Il secondo terminerà più rapidamente nel caso di una stringa non numerica, poiché rifiuterà il primo carattere non valido.

Inoltre, controllare il metodo String # to_i - è forse fa ciò che si vuole:
http://www.ruby-doc.org/core/classes/String.html#M000787

Answer 4

Non so se questo è veloce, ma mi piace:

class String 
def numeric? 
    true if Integer(object) rescue false 
end 
end 

gestisce i numeri negativi anche. E se mai volessi supportare i float in futuro, usa semplicemente Float()

Answer 5

Non sono sicuro al 100% ma Rails sembra utilizzare /\A[+-]?\d+\Z/ per i numeri interi.
Clicca in mostra fonte per validates_numericality_ofhere

Answer 6

Secondo un semplice punto di riferimento, il secondo approccio è più veloce, anche se io non sono esperto di benchmarker, quindi questo potrebbe non essere un punto di riferimento valida: la logica http://pastie.org/586777

Zalus' è giusto. Deve solo controllare una volta per una stringa non valida.

Answer 7

Suggerirei un altro modo di farlo. Inoltre, poiché hai chiesto un numero intero "positivo", ho realizzato due metodi separati per intero positivo e numero intero non negativo.

class String 
    def numeric? 
    !self.match(/[^0-9]/) 
    end 

    def positive_integer? 
    self.to_i > 0 
    end 

    def nonnegative_integer? 
    self.to_i > 0 or self == '0' 
    end 
end 

Ecco il codice di riferimento:

require 'benchmark' 
include Benchmark 

bmbm(100) do |x| 
    x.report('numeric?') do 
    "some invalid string".numeric? 
    end 

    x.report('positive_integer?') do 
    "some invalid string".positive_integer? 
    end 

    x.report('nonnegative_integer?') do 
    "some invalid string".nonnegative_integer? 
    end 
end 

Risultato:

numeric? 
0.000000 0.000000 0.000000 ( 0.000045) 
positive_integer? 
0.000000 0.000000 0.000000 ( 0.000012) 
nonnegative_integer? 
0.000000 0.000000 0.000000 ( 0.000015) 

Sembra positive_integer? e nonnegative_integer? sono più veloci in questo micro-benchmark.

Infine, come nota a margine, è possibile definire integer? metodo in un modo simile:

class String 
    def integer? 
    self.to_i.to_s == self 
    end 
end 

Answer 8

Avviso

n = '1234' 
n.to_i.to_s == n 
=> true 

n2 = '1.3' 
n.to_i.to_s == n2 
=> false 

lavori per positivi & interi negativi, ma le rappresentazioni non ottale/esagonali, galleggianti, ecc. Potrebbe non funzionare al meglio (non testato), ma senza perdere tempo con ottimizzazioni premature.