ทดสอบว่าสตริงเป็นตัวเลขใน Ruby on Rails หรือไม่

ฉันมีสิ่งต่อไปนี้ในตัวควบคุมแอปพลิเคชันของฉัน:

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

และเงื่อนไขต่อไปนี้ในคอนโทรลเลอร์ของฉัน:

if mystring.is_number?

end

เงื่อนไขคือการโยนundefined methodข้อผิดพลาด ฉันเดาว่าฉันกำหนดis_numberผิด ... ?

สร้างis_number?วิธีการ

สร้างวิธีการช่วยเหลือ:

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

แล้วเรียกแบบนี้ว่า

my_string = '12.34'

is_number?( my_string )
# => true

ขยายStringชั้นเรียน

หากคุณต้องการให้สามารถโทรis_number?โดยตรงบนสตริงแทนที่จะส่งเป็นพารามิเตอร์ไปยังฟังก์ชันตัวช่วยของคุณคุณต้องกำหนดis_number?เป็นส่วนขยายของStringคลาสดังนี้:

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

จากนั้นคุณสามารถเรียกมันด้วย:

my_string.is_number?
# => true

นี่คือเกณฑ์มาตรฐานสำหรับวิธีทั่วไปในการแก้ไขปัญหานี้ สังเกตว่าคุณควรใช้อันไหนขึ้นอยู่กับอัตราส่วนของกรณีเท็จที่คาดไว้

1. หากพวกเขามีการคัดเลือกนักแสดงที่ค่อนข้างผิดปกติแน่นอน
2. หากกรณีเท็จเป็นเรื่องปกติและคุณเพิ่งตรวจสอบ ints การเปรียบเทียบกับสถานะที่แปลงแล้วเป็นตัวเลือกที่ดี
3. หากกรณีเท็จเป็นเรื่องปกติและคุณกำลังตรวจสอบการลอยอยู่ regexp น่าจะเป็นหนทางไป

หากประสิทธิภาพไม่สำคัญให้ใช้สิ่งที่คุณชอบ :-)

รายละเอียดการตรวจสอบจำนวนเต็ม:

# 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

รายละเอียดการตรวจสอบลอย:

# 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

การอาศัยข้อยกเว้นที่เพิ่มขึ้นไม่ใช่วิธีแก้ปัญหาที่เร็วที่สุดอ่านได้และเชื่อถือได้
ฉันจะทำสิ่งต่อไปนี้:

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

ในฐานะของทับทิม 2.6.0 ที่เป็นตัวเลขหล่อวิธีการมีตัวเลือกexception-argument [1] สิ่งนี้ช่วยให้เราใช้วิธีการในตัวโดยไม่ต้องใช้ข้อยกเว้นเป็นขั้นตอนการควบคุม:

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

ดังนั้นคุณไม่จำเป็นต้องกำหนดวิธีการของคุณเอง แต่สามารถตรวจสอบตัวแปรได้โดยตรงเช่น

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

นี่คือวิธีที่ฉันทำ แต่ฉันคิดว่ามันต้องมีวิธีที่ดีกว่านี้

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

Tl; dr:ใช้วิธี regex เร็วกว่าวิธีการช่วยเหลือ 39 เท่าในคำตอบที่ยอมรับและยังจัดการกรณีเช่น "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

-

คำตอบที่ได้รับการยอมรับจาก @Jakob S นั้นใช้ได้ผลเป็นส่วนใหญ่ แต่การจับข้อยกเว้นอาจช้ามาก นอกจากนี้วิธีการช่วยเหลือล้มเหลวในสตริงเช่น "1,000"

มากำหนดวิธีการ:

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

และตอนนี้บางกรณีทดสอบ:

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

และรหัสเล็กน้อยเพื่อเรียกใช้กรณีทดสอบ:

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

นี่คือผลลัพธ์ของกรณีทดสอบ:

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

ถึงเวลาทำเกณฑ์มาตรฐานประสิทธิภาพ:

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

และผลลัพธ์:

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

ไม่คุณแค่ใช้ผิด is_number ของคุณ? มีข้อโต้แย้ง คุณเรียกมันโดยไม่มีข้อโต้แย้ง

คุณควรจะทำ is_number? (mystring)

ในราง 4 คุณต้องใส่ require File.expand_path('../../lib', __FILE__) + '/ext/string' config / application.rb ของคุณ

หากคุณไม่ต้องการใช้ข้อยกเว้นเป็นส่วนหนึ่งของตรรกะคุณอาจลองสิ่งนี้:

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

หรือถ้าคุณต้องการให้มันทำงานกับคลาสอ็อบเจ็กต์ทั้งหมดให้แทนที่class Stringด้วยclass Objectการแปลงตัวเองเป็นสตริง: !!(self.to_s =~ /^-?\d+(\.\d*)?$/)

ใช้ฟังก์ชันต่อไปนี้:

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

ดังนั้น,

is_numeric? "1.2f" = เท็จ

is_numeric? "1.2" = จริง

is_numeric? "12f" = เท็จ

is_numeric? "12" = จริง

วิธีแก้ปัญหานี้เป็นใบ้แค่ไหน?

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