Check if string contains only positive numbers in Ruby

Question

I am really new to ruby and want know if it's possible to check if a string contains only positive numbers using regex or some other function?

str = "123abcd"  #return false because it contains alphabets
str = "153"      #return true because of all numbers

By "positive digits", I presume you mean 1-9. Is that correct, or do you mean '0-9' (in which case you should strike "positive")? — Cary Swoveland, Feb 16 '14 at 18:27
There is no such thing as "positive digits". One or more digits express(es) a number. A number can be positive or not. `0` by itself expresses a non-positive number. The `0` in `10` is part of a positive number. You cannot say whether `0` as a digit is positive or not. Similarly, `1` alone is a positive number. `1` in `-1` is part of a negative number. — sawa, Feb 16 '14 at 20:22
I realized that the original question said "positive numbers" and Wayne edited to "positive digits". The original one was better. — sawa, Feb 16 '14 at 20:40
Interesting. If that's the case, then all the solutions are wrong because of strings like "+15" or "2.0e+40" — Mark Thomas, Feb 16 '14 at 20:48
@MarkThomas You are right. The question is actually a difficult one if that is what was intended. The question is not clear for sure. — sawa, Feb 16 '14 at 20:56
Sloppily-worded questions like this one are time-wasting and annoying, doubly-so when the asker takes no action rectify the problem. — Cary Swoveland, Feb 17 '14 at 01:24

score 20 · Answer 1 · answered Feb 16 '14 at 17:56

20

All other answers so far using regex are inefficient.

"123abcd" !~ /\D/ # => false
"153" !~ /\D/     # => true

answered Feb 16 '14 at 17:56

sawa

165,429
45
277
381

1

So you consider all non-negated regex matches inefficient? I think the difference would be insignificant for most real-world cases. – Mark Thomas Feb 16 '14 at 20:35
In addition to efficiency, those regexes are more complicated. There is no reason to use them. – sawa Feb 16 '14 at 20:37
3

I agree, and I voted up your answer because of its simplicity. However, I don't think I'd flag anyone in a code review for using `=~` over `!~`. Regular expressions are still fairly efficient. "Less efficient" != "inefficient". – Mark Thomas Feb 16 '14 at 20:42
1

It gives wrong value if the string is empty `'' !~ /\D/` – Abibullah Rahamathulah Oct 22 '14 at 10:56
@AbibullahRahamathulah No, it doesn't. It correctly returns `true`. – sawa Oct 22 '14 at 11:16
@sawa, for empty string it should return `false` right? – Abibullah Rahamathulah Oct 22 '14 at 16:19
@AbibullahRahamathulah Of course not. – sawa Oct 22 '14 at 16:20

score 5 · Accepted Answer · answered Feb 16 '14 at 16:59

5

Of course Regexp is good for this:

string = "123abcd"
/^(?<num>\d+)$/ =~ string
num # => nil

string = "123"
/^(?<num>\d+)$/ =~ string
num # => '123' # String

So if you need to check the condition:

if /^(?<num>\d+)$/ =~ string
   num.to_i # => 123
   # do something...
end

#to_i method of String isn't valid for your case because it will return a number, if string is even with letters:

string = "123abcd"
string.to_i # 123

answered Feb 16 '14 at 16:59

Малъ Скрылевъ

16,187
5
56
69

It works, but is inefficient. – sawa Feb 16 '14 at 17:57
1

2nd downvoter are you weak to explain that? – Малъ Скрылевъ Jan 30 '15 at 11:29
Wouldn't `/[-+]*\d/` also work? It's a lot simpler – Zac Oct 10 '16 at 18:00
@Zac the askwer requires to match only positive letter, but your solution will match negative ones, also with an only a first digit, and many +- signs, what is it? – Малъ Скрылевъ Oct 11 '16 at 09:53
Oh yeah - I didn't realise it was only positive – Zac Oct 11 '16 at 15:38

score 4 · Answer 3 · answered Feb 16 '14 at 17:02

4

if '123'.match(/^\d+$/)
  # code
end

answered Feb 16 '14 at 17:02

Danil Speransky

29,891
5
68
79

It works, but is inefficient. – sawa Feb 16 '14 at 17:58
@sawa Can you explain why this is less efficient than your negated answer? – Mark Thomas Feb 16 '14 at 18:24
@MarkThomas When the string contains a non-digit, my regex does not need to carry the information of a matching candidate because (mis-)match is decided by looking at a single character. It just needs to increment the start position to apply the pattern. The regex in this answer has to keep track of the matching candidate information (sequence of digits) up to the point it fails. – sawa Feb 16 '14 at 18:43
@sawa I don't see how this needs to track anything, as there are no capture groups. As soon as you see a non-digit, this can fail. – Mark Thomas Feb 16 '14 at 18:46
@MarkThomas Having no capture group only means that it does not need to keep track of any substring of the match. But it needs to keep the entire match during the matching process in case it succeeds, even if it eventually turns out to fail. A matchdata object has the information of the entire matched string. – sawa Feb 16 '14 at 20:03
@sawa Ah, so you not are referring to the regex but the fact that the `match` method returns a MatchData object. Would `"123" =~ /^\d+$/` be better? – Mark Thomas Feb 16 '14 at 20:11
@MarkThomas Still in that case, the matchdata is kept in `$~`. – sawa Feb 16 '14 at 20:13

score 2 · Answer 4 · edited May 23 '17 at 12:10

2

I' do using Regexp#=== as below :

str = "123abcd"
/^\d+$/ === str  # => false # because string not only contains digits
str = "153" 
/^\d+$/ === str  # => true  # because string only contains digits

update (considering @sawa's comment1 and comment2)

str = "123abcd"
/\D/ === str  # => true  # because string contains non-digit
str = "153" 
/\D/ === str  # => false # because string doesn't contain any non-digit

edited May 23 '17 at 12:10

Community

1
1

answered Feb 16 '14 at 17:11

Arup Rakshit

116,827
30
260
317

It works, but is inefficient. – sawa Feb 16 '14 at 17:57
@sawa Thanks for your review. Could you tell me why is it efficient? Asking out of curiosity. – Arup Rakshit Feb 16 '14 at 17:59
1

If a string includes a non-digit character, it becomes clear at that point that it should return false, and there is no need to look further into the string. But your regex scans the entire string. – sawa Feb 16 '14 at 18:01
Actually, the condition is more complicated than is necessary. – sawa Feb 16 '14 at 18:07
@sawa I joined SO to learn, so tried to improve it. Please review it. – Arup Rakshit Feb 16 '14 at 18:16
1

Good food for thought. – Cary Swoveland Feb 16 '14 at 18:18
1

Using `Regexp#===` in this way is not very idiomatic. – Mark Thomas Feb 16 '14 at 18:44
@ArupRakshit I think I am explaining it better in comments to Speransky Danil's answer. Please read there if you are interested. – sawa Feb 16 '14 at 20:16

Cary Swoveland · Answer 5 · 2014-02-17T01:11:58.877

0

I originally answered this when "only positive digits" was a requirement, but I see that has been changed to "only positive numbers" (the original wording), which, in part because of the example given (which rules out the interpretation "12abc34" => true, "12abc-34" => false and does not suggest the interpretation "1.5abc" => true), I take to mean "one positive integer". My assumption is stated more precisely by my answer:

str =~ /^0*[1-9]\d*$/

This question raises another: "How many Rubiests can dance on the head of a pin?". Maybe it's just a slow-news day. Thanks to @sawa and @Mark for their comments.

edited Feb 17 '14 at 01:11

answered Feb 16 '14 at 18:06

Cary Swoveland

106,649
6
63
100

Logic error: returns `true` for an empty string. You want `+`. – Mark Thomas Feb 16 '14 at 18:33
1

@Mark, I mulled that, but decided to go with `*`, as I figured the asker did not mean "only positive digits" literally, for if/she did, one could argue that false should be returned for strings of length one, which I don't think was intended. Was the downvote yours? – Cary Swoveland Feb 16 '14 at 19:57
1

Yes, but I will remove it if you put your (completely valid) interpretation of the unstated requirements in the answer. – Mark Thomas Feb 16 '14 at 20:16
Even more fatal is the fact the no zero is allowed. It excludes numbers like `10`. The question originally said "positive numbers", and was edited by Wayne to "positive digits", which does not have clear meaning. – sawa Feb 16 '14 at 20:42
@sawa, I wasn't aware of the edit you mentioned, but will fix. Mark, thanks for the suggestion. Will do. – Cary Swoveland Feb 16 '14 at 21:47

Check if string contains only positive numbers in Ruby

5 Answers5

Linked