how to check if string is a valid number (Page 1 of 2)

regular expressions will do.

/^[\d]+(\.[\d]+){0,1}$/ === "23.362" => true
/^[\d]+(\.[\d]+){0,1}$/ === "23.36.2" => false
/^[\d]+(\.[\d]+){0,1}$/ === "2362" => true

Duplex, using .to_f.to_s, "0" would be returned as not-a-number

Your reply is confusing now as i removed my post after seeing better replies

anyway, your're wrong as i did a comparison which would simply return true/false:

#if self is a string:
self.to_i.to_s == self
#should return true as "1".to_i.to_s is "1" 
#(for integers of course, floats are a different thing)

Here's a revised version that works for floats too.

#!/usr/bin/ruby -w
def is_a_number?(s)
  s.to_s.match(/\A[+-]?\d+?(\.\d+)?\Z/) == nil ? false : true 
end
puts is_a_number?(5)
puts is_a_number?("+256.375")
puts is_a_number?("-37.3")
puts is_a_number?("x")
puts is_a_number?(-37.3)
puts is_a_number?("2.3.3")

Good call on the negative numbers! Glad someone caught that!

On a related note the to_f and to_i methods are almost too good. If it can't parse something it returns either 0 or the components of it that it could figure out. That leads to ambiguous results since "ASDFasdfasfd".to_i returns 0 instead of nil or raising an exception.

Nice and simple. And the rescue clause makes it bulletproof. I like it!

Thanks, this was a very helpful thread - I thought I'd share my quicky bench test of the two methods because the performance results that I got was not what I expected:

arry = %w[a 1a a2 1.0b 1.1.0 0 1 1.1 0.1 -1 ]

def is_numeric?(i)
    i.to_i.to_s == i || i.to_f.to_s == i
end

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

a = Time.now
100000.times  { arry.each { |n| is_numeric?(n) } }
puts Time.now - a

a = Time.now
100000.times { arry.each { |n| is_number?(n) } }
puts Time.now - a

I get:
6.1308
13.1352

So explicitly creating a Float is twice as slow as converting to an integer or float and back to a string.
I also ran this with all values that would return false and got more of a 3 times slowdown, so I wonder if it has more to do with exception handling than object creation?

I know this thread is kind of old now, but I'd like to point out that the regular expression method of detection shown above does not correspond completely with the Float() method. Specifically, calling:

is_a_number?(".0")

yields false in irb (1.8.7) while Float(".0") yields 0.0 (or true using ChrisJ's is_number? method above)

For some situations, catching ".0" as valid may be important.

Likewise using either the num.to_i.to_s or num.to_f.to_s is problematic if the input may be a numeric string in a non-normalized form: "09".to_i.to_s != "9" and "5e-1".to_f.to_s != "0.5"

For these reasons I prefer the apparently slower Float() method (minzastro's is_a_number? method) better when you want to catch these valid though possibly non-normalized numeric strings.

I know this is old, but wanna see something cool?

begin Float("Test") ; true end rescue false

returns false

Or as a one-liner extension to Number:

class String
  def is_numeric?
    begin Float(self) ; true end rescue false
  end
end

Or, more readable:

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

Works for floats, and specifically why I was interested - works for "0" just fine. (string.to_f does not, as "0".to_f == 0 and "Anything".to_f == 0)